{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "try:\n",
    "    del X_train, y_train\n",
    "    del X_test, y_test\n",
    "    print('Clear previously loaded data.')\n",
    "except:\n",
    "    pass\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.338072\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 1:\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "**Your answer:** *Fill this in*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: 3.543109 analytic: 3.543108, relative error: 3.416443e-08\n",
      "numerical: -0.218225 analytic: -0.218225, relative error: 8.386467e-08\n",
      "numerical: -0.567054 analytic: -0.567054, relative error: 6.148613e-08\n",
      "numerical: -0.803762 analytic: -0.803762, relative error: 5.486405e-08\n",
      "numerical: -0.821687 analytic: -0.821687, relative error: 4.465327e-10\n",
      "numerical: 0.394040 analytic: 0.394040, relative error: 4.740465e-08\n",
      "numerical: 0.235108 analytic: 0.235108, relative error: 9.759911e-08\n",
      "numerical: 0.306877 analytic: 0.306877, relative error: 5.394319e-08\n",
      "numerical: 0.324750 analytic: 0.324750, relative error: 1.132218e-07\n",
      "numerical: -3.450826 analytic: -3.450826, relative error: 7.415536e-09\n",
      "numerical: -0.976677 analytic: -0.976677, relative error: 5.623260e-08\n",
      "numerical: 1.439261 analytic: 1.439261, relative error: 3.184214e-09\n",
      "numerical: 2.042020 analytic: 2.042020, relative error: 2.882694e-08\n",
      "numerical: -0.211860 analytic: -0.211860, relative error: 7.228027e-08\n",
      "numerical: 0.282145 analytic: 0.282145, relative error: 1.158473e-07\n",
      "numerical: -0.066467 analytic: -0.066467, relative error: 4.690361e-08\n",
      "numerical: 0.853511 analytic: 0.853511, relative error: 4.580518e-09\n",
      "numerical: -3.462364 analytic: -3.462365, relative error: 2.484116e-08\n",
      "numerical: -1.182523 analytic: -1.182523, relative error: 1.255909e-08\n",
      "numerical: 2.502794 analytic: 2.502794, relative error: 6.758485e-09\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.5 1.  1.5]\n",
      " [2.  2.5 3.5]]\n",
      "[0 1 2 3 4]\n",
      "range(0, 5)\n"
     ]
    }
   ],
   "source": [
    "A=np.array([[1,2,3],[4,5,7]])\n",
    "print(A/[[2],[2]])\n",
    "print(np.arange(5))\n",
    "print(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.338072e+00 computed in 0.234304s\n",
      "vectorized loss: 2.338072e+00 computed in 0.269994s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 1000: loss 311.959401\n",
      "iteration 100 / 1000: loss 208.340730\n",
      "iteration 200 / 1000: loss 140.053055\n",
      "iteration 300 / 1000: loss 94.220109\n",
      "iteration 400 / 1000: loss 63.671852\n",
      "iteration 500 / 1000: loss 43.170960\n",
      "iteration 600 / 1000: loss 29.533119\n",
      "iteration 700 / 1000: loss 20.473188\n",
      "iteration 800 / 1000: loss 14.317599\n",
      "iteration 900 / 1000: loss 10.257190\n",
      "iteration 0 / 1000: loss 770.287906\n",
      "iteration 100 / 1000: loss 282.752579\n",
      "iteration 200 / 1000: loss 104.843172\n",
      "iteration 300 / 1000: loss 39.646707\n",
      "iteration 400 / 1000: loss 15.832108\n",
      "iteration 500 / 1000: loss 7.143364\n",
      "iteration 600 / 1000: loss 3.917528\n",
      "iteration 700 / 1000: loss 2.772084\n",
      "iteration 800 / 1000: loss 2.353607\n",
      "iteration 900 / 1000: loss 2.150276\n",
      "iteration 0 / 1000: loss 1555.423802\n",
      "iteration 100 / 1000: loss 209.450566\n",
      "iteration 200 / 1000: loss 29.883266\n",
      "iteration 300 / 1000: loss 5.821723\n",
      "iteration 400 / 1000: loss 2.634461\n",
      "iteration 500 / 1000: loss 2.234502\n",
      "iteration 600 / 1000: loss 2.126853\n",
      "iteration 700 / 1000: loss 2.201338\n",
      "iteration 800 / 1000: loss 2.206130\n",
      "iteration 900 / 1000: loss 2.122148\n",
      "iteration 0 / 1000: loss 319.362047\n",
      "iteration 100 / 1000: loss 96.077292\n",
      "iteration 200 / 1000: loss 30.063305\n",
      "iteration 300 / 1000: loss 10.393260\n",
      "iteration 400 / 1000: loss 4.478363\n",
      "iteration 500 / 1000: loss 2.727237\n",
      "iteration 600 / 1000: loss 2.247930\n",
      "iteration 700 / 1000: loss 2.007165\n",
      "iteration 800 / 1000: loss 2.065525\n",
      "iteration 900 / 1000: loss 2.008969\n",
      "iteration 0 / 1000: loss 769.922362\n",
      "iteration 100 / 1000: loss 39.164722\n",
      "iteration 200 / 1000: loss 3.886494\n",
      "iteration 300 / 1000: loss 2.119929\n",
      "iteration 400 / 1000: loss 2.166276\n",
      "iteration 500 / 1000: loss 2.124295\n",
      "iteration 600 / 1000: loss 2.103289\n",
      "iteration 700 / 1000: loss 2.044988\n",
      "iteration 800 / 1000: loss 2.095079\n",
      "iteration 900 / 1000: loss 2.055157\n",
      "iteration 0 / 1000: loss 1539.081890\n",
      "iteration 100 / 1000: loss 5.561127\n",
      "iteration 200 / 1000: loss 2.123650\n",
      "iteration 300 / 1000: loss 2.127015\n",
      "iteration 400 / 1000: loss 2.179975\n",
      "iteration 500 / 1000: loss 2.156967\n",
      "iteration 600 / 1000: loss 2.191171\n",
      "iteration 700 / 1000: loss 2.140168\n",
      "iteration 800 / 1000: loss 2.131286\n",
      "iteration 900 / 1000: loss 2.183651\n",
      "iteration 0 / 1000: loss 313.591432\n",
      "iteration 100 / 1000: loss 42.968563\n",
      "iteration 200 / 1000: loss 7.410224\n",
      "iteration 300 / 1000: loss 2.709015\n",
      "iteration 400 / 1000: loss 2.156802\n",
      "iteration 500 / 1000: loss 2.009298\n",
      "iteration 600 / 1000: loss 2.020358\n",
      "iteration 700 / 1000: loss 2.016639\n",
      "iteration 800 / 1000: loss 2.056133\n",
      "iteration 900 / 1000: loss 2.041937\n",
      "iteration 0 / 1000: loss 773.914978\n",
      "iteration 100 / 1000: loss 6.860099\n",
      "iteration 200 / 1000: loss 2.097292\n",
      "iteration 300 / 1000: loss 2.131434\n",
      "iteration 400 / 1000: loss 2.065543\n",
      "iteration 500 / 1000: loss 2.088380\n",
      "iteration 600 / 1000: loss 2.097275\n",
      "iteration 700 / 1000: loss 2.100784\n",
      "iteration 800 / 1000: loss 2.092616\n",
      "iteration 900 / 1000: loss 2.128657\n",
      "iteration 0 / 1000: loss 1556.837300\n",
      "iteration 100 / 1000: loss 2.215907\n",
      "iteration 200 / 1000: loss 2.139021\n",
      "iteration 300 / 1000: loss 2.120221\n",
      "iteration 400 / 1000: loss 2.180716\n",
      "iteration 500 / 1000: loss 2.148673\n",
      "iteration 600 / 1000: loss 2.103722\n",
      "iteration 700 / 1000: loss 2.132223\n",
      "iteration 800 / 1000: loss 2.146151\n",
      "iteration 900 / 1000: loss 2.168059\n",
      "lr 1.000000e-07 reg 1.000000e+04 train accuracy: 0.331633 val accuracy: 0.356000\n",
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.325306 val accuracy: 0.342000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.311694 val accuracy: 0.325000\n",
      "lr 3.000000e-07 reg 1.000000e+04 train accuracy: 0.355735 val accuracy: 0.374000\n",
      "lr 3.000000e-07 reg 2.500000e+04 train accuracy: 0.335796 val accuracy: 0.349000\n",
      "lr 3.000000e-07 reg 5.000000e+04 train accuracy: 0.303755 val accuracy: 0.319000\n",
      "lr 5.000000e-07 reg 1.000000e+04 train accuracy: 0.353755 val accuracy: 0.369000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.328204 val accuracy: 0.337000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.288122 val accuracy: 0.306000\n",
      "best validation accuracy achieved during cross-validation: 0.374000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [1e-7, 3e-7,5e-7]\n",
    "regularization_strengths = [1e4, 2.5e4, 5e4]\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "for i in range(0,3):\n",
    "    for j in range(0,3):\n",
    "        sof=Softmax()\n",
    "        loss_hist=sof.train(X_train, y_train, learning_rate=learning_rates[i],\\\n",
    "                            reg=regularization_strengths[j],num_iters=1000,\\\n",
    "                            verbose=True)\n",
    "        y_pred_trn=sof.predict(X_train)\n",
    "        y_pred_val=sof.predict(X_val)\n",
    "        trn_accu=np.mean(y_pred_trn==y_train)\n",
    "        val_accu=np.mean(y_pred_val==y_val)\n",
    "        results[(learning_rates[i], regularization_strengths[j])]=(trn_accu,val_accu)\n",
    "        if val_accu>best_val:\n",
    "            best_val=val_accu\n",
    "            best_softmax=sof\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.369000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Inline Question** - *True or False*\n",
    "\n",
    "It's possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "*Your answer*:\n",
    "\n",
    "*Your explanation*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
